// WeeklyRankingJobConfig.java
@ConditionalOnProperty(name = "spring.batch.job.name", havingValue = "weeklyRankingJob")
@Configuration
public class WeeklyRankingJobConfig {
    public static final String JOB_NAME = "weeklyRankingJob";
    private static final int CHUNK_SIZE = 100;  // TOP 100이므로 한 번에 처리
    
    @Bean(JOB_NAME)
    public Job weeklyRankingJob() {
        return new JobBuilder(JOB_NAME, jobRepository)
            .incrementer(new RunIdIncrementer())
            .start(weeklyAggregationStep())
            .listener(jobListener)
            .build();
    }
    
    @Bean("weeklyAggregationStep")
    @JobScope
    public Step weeklyAggregationStep() {
        return new StepBuilder("weeklyAggregationStep", jobRepository)
            .<RankingAggregation, RankingAggregation>chunk(CHUNK_SIZE, transactionManager)
            .reader(weeklyMetricsReader)
            .processor(rankingProcessor)
            .writer(weeklyRankWriter)
            .listener(stepMonitorListener)
            .build();
    }
}

// WeeklyMetricsReader.java
@StepScope
@Component
public class WeeklyMetricsReader implements ItemReader<RankingAggregation> {
    
    @Value("#{jobParameters['yearWeek']}")
    private String yearWeek;  // e.g., "2024-W52"
    
    @Override
    public RankingAggregation read() {
        if (iterator == null) {
            // 1. 주차 → 날짜 범위 변환
            LocalDate[] dateRange = dateRangeParser.parseYearWeek(yearWeek);
            
            // 2. DB 집계 쿼리 실행
            List<Object[]> results = repository.aggregateByDateRange(
                dateRange[0], dateRange[1]);
            
            // 3. 집계 + 점수 계산 + 정렬 + TOP 100 + 순위 부여
            List<RankingAggregation> aggregations = rankingAggregator
                .aggregateAndRank(results, scoreCalculator, 100);
            
            iterator = aggregations.iterator();
        }
        return iterator.hasNext() ? iterator.next() : null;
    }
}

// WeeklyRankWriter.java
@StepScope
@Component
public class WeeklyRankWriter implements ItemWriter<RankingAggregation> {
    
    @Value("#{jobParameters['yearWeek']}")
    private String yearWeek;
    
    @Override
    public void write(Chunk<? extends RankingAggregation> chunk) {
        List<WeeklyRankEntity> entities = chunk.getItems().stream()
            .map(agg -> WeeklyRankEntity.create(
                agg.getProductId(), yearWeek, agg.getViewCount(),
                agg.getLikeCount(), agg.getSalesCount(), agg.getOrderCount(),
                agg.getTotalScore(), agg.getRankPosition()))
            .toList();
            
        // 멱등성 보장: 기존 데이터 삭제 후 저장
        repository.deleteByYearWeek(yearWeek);
        repository.saveAll(entities);
    }
}

// ScoreCalculator.java

@Component
public class ScoreCalculator {
    private static final int VIEW_WEIGHT = 1;
    private static final int LIKE_WEIGHT = 3;
    private static final int SALES_WEIGHT = 5;
    private static final int ORDER_WEIGHT = 2;
    
    public long calculate(long viewCount, long likeCount, long salesCount, long orderCount) {
        return viewCount * VIEW_WEIGHT 
             + likeCount * LIKE_WEIGHT 
             + salesCount * SALES_WEIGHT 
             + orderCount * ORDER_WEIGHT;
    }
}

// ScoreCalculatorUnitTest.java
@Test
@DisplayName("가중치가 올바르게 적용되어 점수가 계산된다")
void should_calculate_score_with_correct_weights() {
    // given
    long viewCount = 100, likeCount = 50, salesCount = 10, orderCount = 5;
    
    // when
    long score = scoreCalculator.calculate(viewCount, likeCount, salesCount, orderCount);
    
    // then
    // 100*1 + 50*3 + 10*5 + 5*2 = 310
    assertThat(score).isEqualTo(310L);
}

// DateRangeParser.java
@Component
public class DateRangeParser {
    
    public LocalDate[] parseYearWeek(String yearWeek) {
        // "2024-W52" → [2024-12-23, 2024-12-29]
        WeekFields weekFields = WeekFields.ISO;
        String[] parts = yearWeek.split("-W");
        int year = Integer.parseInt(parts[0]);
        int week = Integer.parseInt(parts[1]);
        
        LocalDate startOfWeek = LocalDate.of(year, 1, 1)
            .with(weekFields.weekOfYear(), week)
            .with(weekFields.dayOfWeek(), 1);
        LocalDate endOfWeek = startOfWeek.plusDays(6);
        
        return new LocalDate[]{startOfWeek, endOfWeek};
    }
}

// DateRangeParserUnitTest.java
@Test
@DisplayName("2024년 52주차를 올바른 날짜 범위로 파싱한다")
void should_parse_year_week_to_correct_date_range() {
    // when
    LocalDate[] result = dateRangeParser.parseYearWeek("2024-W52");
    
    // then
    assertThat(result[0]).isEqualTo(LocalDate.of(2024, 12, 23)); // 월요일
    assertThat(result[1]).isEqualTo(LocalDate.of(2024, 12, 29)); // 일요일
}

// RankingAggregator.java
@Component
public class RankingAggregator {
    
    public List<RankingAggregation> aggregateAndRank(
            List<Object[]> dbResults, ScoreCalculator calculator, int topN) {
        
        List<RankingAggregation> aggregations = dbResults.stream()
            .map(row -> RankingAggregation.from(row, calculator))
            .sorted(Comparator.comparingLong(RankingAggregation::getTotalScore).reversed())
            .limit(topN)
            .toList();
        
        // 순위 부여
        for (int i = 0; i < aggregations.size(); i++) {
            aggregations.get(i).assignRank(i + 1);
        }
        
        return aggregations;
    }
}

// RankingAggregatorUnitTest.java
@Test
@DisplayName("점수 순으로 정렬하고 TOP N을 선택하여 순위를 부여한다")
void should_sort_by_score_and_assign_ranks_for_top_n() {
    // given
    List<Object[]> dbResults = List.of(
        new Object[]{1L, 100L, 50L, 10L, 5L},  // 점수: 310
        new Object[]{2L, 200L, 30L, 5L, 3L},   // 점수: 281
        new Object[]{3L, 50L, 100L, 20L, 10L}  // 점수: 470
    );
    
    // when
    List<RankingAggregation> result = aggregator.aggregateAndRank(dbResults, calculator, 2);
    
    // then
    assertThat(result).hasSize(2);
    assertThat(result.get(0).getProductId()).isEqualTo(3L);  // 1위: 470점
    assertThat(result.get(0).getRankPosition()).isEqualTo(1);
    assertThat(result.get(1).getProductId()).isEqualTo(1L);  // 2위: 310점
    assertThat(result.get(1).getRankPosition()).isEqualTo(2);
}

// WeeklyRankId.java
@Embeddable
@Getter
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode  // 복합키는 equals/hashCode 필수
public class WeeklyRankId implements Serializable {
    
    @Column(name = "product_id", nullable = false)
    private Long productId;
    
    @Column(name = "year_week", nullable = false)
    private String yearWeek;
    
    public static WeeklyRankId of(Long productId, String yearWeek) {
        return new WeeklyRankId(productId, yearWeek);
    }
}

// WeeklyRankEntity.java
@Entity
@Getter
@Table(
    name = "mv_product_rank_weekly",
    indexes = @Index(name = "idx_year_week_rank", columnList = "year_week, rank_position")
)
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class WeeklyRankEntity {

    @EmbeddedId
    private WeeklyRankId id;

    @Column(name = "view_count", nullable = false)
    private long viewCount = 0L;
    
    @Column(name = "like_count", nullable = false)
    private long likeCount = 0L;
    
    @Column(name = "sales_count", nullable = false)
    private long salesCount = 0L;
    
    @Column(name = "order_count", nullable = false)
    private long orderCount = 0L;
    
    @Column(name = "total_score", nullable = false)
    private long totalScore = 0L;
    
    @Column(name = "rank_position", nullable = false)
    private int rankPosition;

    public static WeeklyRankEntity create(Long productId, String yearWeek,
            long viewCount, long likeCount, long salesCount, long orderCount,
            long totalScore, int rankPosition) {
        return new WeeklyRankEntity(productId, yearWeek, viewCount, likeCount,
                salesCount, orderCount, totalScore, rankPosition);
    }

    // 편의 메서드
    public Long getProductId() {
        return id.getProductId();
    }

    public String getYearWeek() {
        return id.getYearWeek();
    }
    
    private void validateRankPosition(int rankPosition) {
        if (rankPosition < 1 || rankPosition > 100) {
            throw new IllegalArgumentException(
                String.format("순위는 1~100 범위여야 합니다. (입력값: %d)", rankPosition));
        }
    }
}

// RankingV1Controller.java
@RestController
@RequiredArgsConstructor
public class RankingV1Controller implements RankingV1ApiSpec {

    private final ProductFacade productFacade;

    @GetMapping(Uris.Ranking.GET_RANKING)
    @Override
    public ApiResponse<PageResponse<ProductV1Dtos.ProductListResponse>> getRankingProducts(
            @PageableDefault(size = 20) Pageable pageable,
            @RequestParam(required = false) LocalDate date
    ) {
        Page<ProductInfo> products = productFacade.getRankingProducts(pageable, date);
        Page<ProductV1Dtos.ProductListResponse> responsePage = products.map(ProductV1Dtos.ProductListResponse::from);
        return ApiResponse.success(PageResponse.from(responsePage));
    }

    @GetMapping(Uris.Ranking.GET_RANKING_BY_PERIOD)
    @Override
    public ApiResponse<PageResponse<ProductV1Dtos.ProductListResponse>> getRankingProductsByPeriod(
            @RequestParam RankingPeriod period,
            @PageableDefault(size = 20) Pageable pageable,
            @RequestParam(required = false) LocalDate date,
            @RequestParam(required = false) String yearWeek,
            @RequestParam(required = false) String yearMonth
    ) {
        // Java 8 Date API를 활용한 파라미터 검증 및 변환
        String processedYearWeek = processYearWeekParameter(yearWeek, date);
        String processedYearMonth = processYearMonthParameter(yearMonth, date);

        Page<ProductInfo> products = productFacade.getRankingProductsByPeriod(
                period, pageable, date, processedYearWeek, processedYearMonth);
        Page<ProductV1Dtos.ProductListResponse> responsePage = products.map(ProductV1Dtos.ProductListResponse::from);
        return ApiResponse.success(PageResponse.from(responsePage));
    }

    /**
     * yearWeek 파라미터 처리
     * - 파라미터가 없으면 현재 주차로 설정
     */
    private String processYearWeekParameter(String yearWeek, LocalDate date) {
        if (yearWeek != null && !yearWeek.trim().isEmpty()) {
            return yearWeek;
        }

        LocalDate targetDate = date != null ? date : LocalDate.now();
        WeekFields weekFields = WeekFields.of(Locale.getDefault());
        int year = targetDate.getYear();
        int week = targetDate.get(weekFields.weekOfYear());
        
        return String.format("%d-W%02d", year, week);
    }

    /**
     * yearMonth 파라미터 처리
     * - 파라미터가 없으면 현재 월로 설정
     */
    private String processYearMonthParameter(String yearMonth, LocalDate date) {
        if (yearMonth != null && !yearMonth.trim().isEmpty()) {
            return yearMonth;
        }

        LocalDate targetDate = date != null ? date : LocalDate.now();
        YearMonth ym = YearMonth.from(targetDate);
        
        return ym.format(DateTimeFormatter.ofPattern("yyyy-MM"));
    }
}

// ProductV1Controller.java (리팩토링 후)
@RestController
@RequiredArgsConstructor
public class ProductV1Controller implements ProductV1ApiSpec {

    private final ProductFacade productFacade;

    @GetMapping(Uris.Product.GET_LIST)
    @Override
    public ApiResponse<PageResponse<ProductV1Dtos.ProductListResponse>> getProducts(...) {
        // 상품 목록 조회 (기존 유지)
    }

    @GetMapping(Uris.Product.GET_DETAIL)
    @Override
    public ApiResponse<ProductV1Dtos.ProductDetailResponse> getProductDetail(...) {
        // 상품 상세 조회 (기존 유지)
    }
    
    // 랭킹 관련 메서드 제거됨 → RankingV1Controller로 이동
}

// RankingApiE2ETest.java
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@DisplayName("Ranking API E2E 테스트")
class RankingApiE2ETest {

    @Nested
    @DisplayName("랭킹 목록 조회 API")
    class GetRankingProductsTest {
        @Test
        @DisplayName("랭킹 데이터가 있으면 점수 순으로 상품 목록을 반환한다")
        void should_return_products_in_ranking_order() { ... }
        
        @Test
        @DisplayName("랭킹 데이터가 없으면 빈 목록을 반환한다")
        void should_return_empty_when_no_ranking_data() { ... }
        
        @Test
        @DisplayName("페이징이 정상적으로 동작한다")
        void should_paginate_ranking_results() { ... }
        
        @Test
        @DisplayName("특정 날짜의 랭킹을 조회할 수 있다")
        void should_return_ranking_for_specific_date() { ... }
    }

    @Nested
    @DisplayName("콜드 스타트 Fallback 테스트")
    class ColdStartFallbackTest {
        @Test
        @DisplayName("오늘 랭킹이 없으면 어제 랭킹을 반환한다")
        void should_fallback_to_yesterday_when_today_is_empty() { ... }
        
        @Test
        @DisplayName("명시적 날짜 지정 시 Fallback하지 않는다")
        void should_not_fallback_when_date_is_explicitly_specified() { ... }
    }

    @Nested
    @DisplayName("상품 상세 조회 시 랭킹 정보 포함 테스트")
    class ProductDetailWithRankingTest { ... }

    @Nested
    @DisplayName("점수 누적 테스트")
    class ScoreAccumulationTest { ... }

    @Nested
    @DisplayName("Score Carry-Over 테스트")
    class CarryOverTest { ... }
}